package com.fjwt.gz.proxy.ctrl.fans;

import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fjwt.gz.core.aop.MethodLog;
import com.fjwt.gz.core.exception.BizException;
import com.fjwt.gz.core.model.ApiRes;
import com.fjwt.gz.db.dto.FansActivityDTO;
import com.fjwt.gz.db.dto.FansAwardDTO;
import com.fjwt.gz.db.dto.FansDTO;
import com.fjwt.gz.db.dto.FansUserDTO;
import com.fjwt.gz.db.entity.FansEntity;
import com.fjwt.gz.db.entity.FansMchEntity;
import com.fjwt.gz.db.vo.FansActivityVO;
import com.fjwt.gz.db.vo.FansVO;
import com.fjwt.gz.db.vo.ScoreRecordTotalVO;
import com.fjwt.gz.proxy.ctrl.CommonCtrl;
import com.fjwt.gz.service.impl.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.Objects;

/**
 * 会员管理
 */
@Slf4j
@RestController
@RequestMapping("/api/fans")
public class FansController extends CommonCtrl {

    @Autowired
    private FansService fansService;

    @Autowired
    private FansMchService fansMchService;

    @Autowired
    private FansUserService fansUserService;

    @Autowired
    private ScoreTotalService scoreTotalService;

    @Autowired
    private FansAgentService fansAgentService;

    /**
     * 校验手机用户验证码
     *
     * @return
     */
    @PostMapping("/checkPhoneCode")
    public ApiRes checkPhoneCode() {
        String phone = getValString("phone");
        String smsCode = getValString("smsCode");
        Long fansId = getValLong("fansId");
        log.info("机构端校验手机用户验证码，请求地址：/api/fans/checkPhoneCode，请求参数：phone：{}，smsCode：{}，fansId：{}", phone, smsCode, fansId);
        fansService.checkPhoneCode(phone, smsCode,  fansId);
        return ApiRes.ok();
    }

    /**
     * 会员管理-列表查询
     */
    @PostMapping("/list")
    public ApiRes getFansByAgents() {
        FansDTO  dto = getObject(FansDTO.class);
        log.info("机构端会员管理-列表查询，请求地址：/api/fans/list，请求参数：dto：{}", dto);
        String agentNo = getCurrentUser().getAgentNo();
        dto.setAgentNo(checkAgentAuth(agentNo, dto.getAgentNo()));
        IPage<FansVO> page = fansService.getList(getIPage(), dto);
        log.info("机构端会员管理-列表查询，返回结果：{}", JSONUtil.toJsonStr(page));
        return ApiRes.page(page);
    }

//    /**
//     * 会员管理-详情
//     */
//    @PreAuthorize("hasAnyAuthority('ENT_FANS_LIST_INFO_VIEW')")
//    @PostMapping("/detail")
//    public ApiRes getFansDetail() {
//        Long fansId = getValLong("fansId");
//        log.info("机构端会员管理-详情，请求地址：/api/fans/detail，请求参数：fansId：{}", fansId);
//        if (Objects.isNull(fansId)) {
//            return ApiRes.customFail("请求参数缺失！");
//        }
//        FansDTO dto = fansService.getFansDetail(fansId, null);
//        // 数据脱敏
//        dto.setPhone(DesensitizedUtil.mobilePhone(dto.getPhone()));
//        dto.setRealName(DesensitizedUtil.chineseName(dto.getRealName()));
//        JSONObject jsonObject = new JSONObject();
//        List<FansMchEntity> saveFile = fansMchService.getSaveFile(fansId);
//        jsonObject.put("saveFile", saveFile);
//        jsonObject.put("fans", dto);
//        log.info("机构端会员管理-详情，请求地址：/api/fans/detail，返回结果：{}", JSONUtil.toJsonStr(jsonObject));
//        return ApiRes.ok(jsonObject);
//    }


    /**
     * 修改会员信息
     *
     * @return
     */
    @PostMapping("/update")
    public ApiRes update() {
        FansEntity object = getObject(FansEntity.class);
        log.info("机构端用户修改个人信息，请求地址：/api/fans/update，请求参数：{}", JSONUtil.toJsonStr(object));
        if (Objects.isNull(object.getFansId())) {
            return ApiRes.customFail("请求参数缺失！");
        }
        FansEntity result = new FansEntity();
        BeanUtils.copyProperties(object, result);
        return ApiRes.ok(fansService.updateById(result));
    }

    /**
     * 查询用户信息以重置商户号
     * @return
     */
    @PostMapping("/getFansMchInfo")
    public ApiRes getFansMchInfo() {
        FansDTO dto = getObject(FansDTO.class);
        log.info("机构端会员管理-查询用户信息以重置商户号，请求地址：/api/fans/getFansMchInfo，请求参数：dto：{}", dto);
        IPage<FansVO> page = fansService.getFansMchInfo(getIPage(), dto);
        log.info("机构端会员管理-查询用户信息以重置商户号，返回结果：{}", JSONUtil.toJsonStr(page));
        return ApiRes.page(page);
    }

    /**
     * 重置用户商户号
     */
    @PreAuthorize("hasAnyAuthority('ENT_COMPARE_MCHINFO_RESET_MCHNO')")
    @MethodLog(remark = "重置用户商户号")
    @PostMapping("/resetMchNo")
    public ApiRes resetMchNo() {
        Long fansId = getValLong("fansId");
        log.info("机构端重置用户商户号，请求地址：/api/fans/resetMchNo，请求参数：fansId：{}", fansId);
        if (null == fansId) {
            return ApiRes.customFail("请求参数缺失！");
        }
        FansEntity fansEntity = fansService.getById(fansId);
        if (null == fansEntity) {
            throw new BizException("用户不存在");
        }
        FansMchEntity fansMchEntity = fansMchService.getOne(FansMchEntity.gw().eq(FansMchEntity::getFansId, fansId));
        if (null == fansMchEntity) {
            throw new BizException("用户未绑定商户号");
        }
        fansMchEntity.setIsDeleted(1);
        log.info("重置用户商户号，修改数据：{}", JSONObject.toJSONString(fansMchEntity));
        boolean flag = fansMchService.updateById(fansMchEntity);
        return flag ? ApiRes.ok() : ApiRes.customFail("操作失败！");
    }

    /**
     * 小程序用户注销功能
     */
//    @PreAuthorize("hasAnyAuthority('ENT_FANS_LIST_INFO_USER_DEL')")
    @MethodLog(remark = "小程序用户注销功能")
    @PostMapping("/delFanUser")
    public ApiRes delFanUser() {
        FansUserDTO fansUserDTO = getObject(FansUserDTO.class);
        // 获取当前用户
        com.fjwt.gz.core.entity.SysUser sysUser = getCurrentUser().getSysUser();
        long currentUserId = sysUser.getSysUserId();
        log.info("小程序用户注销功能，请求地址：/api/fans/delFanUser，请求参数：{},sysUserId:{}", JSONObject.toJSONString(fansUserDTO),  currentUserId);
        this.fansUserService.delFanUser(fansUserDTO, currentUserId);
        return ApiRes.ok();
    }

    /**
     * 测试接口响应
     *
     * @return
     */
    @PostMapping("/a")
    public String a() {
        Date startTime = new Date();
        StringBuilder result = new StringBuilder("接收请求时间：").append(DateUtil.format(startTime, "yyyy-MM-dd HH:mm:ss.SSS"));

        String a = getValString("a");
        result.append(" 接收到的参数：").append(a);

        Date endTime = new Date();
        result.append(" 返回响应时间：").append(DateUtil.format(endTime, "yyyy-MM-dd HH:mm:ss.SSS"));
        result.append(" 耗时：").append(endTime.getTime() - startTime.getTime());
        return result.toString();
    }

    /**
     * 会员管理-获奖记录
     */
    @PostMapping("/fansAndFansAward")
    public ApiRes getFansAndFansAward() {
        FansAwardDTO fansAwardDTO = getObject(FansAwardDTO.class);
        log.info("机构端会员管理-获奖记录，请求地址：/api/fans/fansAndFansAward，请求参数：{}", JSONObject.toJSONString(fansAwardDTO));
        String agentNo = getCurrentUser().getAgentNo();
        fansAwardDTO.setAgentNo(checkAgentAuth(agentNo, fansAwardDTO.getAgentNo()));
        IPage<FansAwardDTO> page = fansService.getFansAndFansAward(getIPage(), fansAwardDTO);
        log.info("机构端会员管理-获奖记录，请求地址：/api/fans/fansAndFansAward，返回结果：{}", JSONObject.toJSONString(page));
        return ApiRes.page(fansService.fansAndFansAward(page));
    }

    /**
     * 会员管理-参与活动列表查询
     */
    @PostMapping("/activityList")
    public ApiRes getFansActivity() {
        FansActivityDTO fansActivityDTO = getObject(FansActivityDTO.class);
        String agentNo = getCurrentUser().getAgentNo();
        fansActivityDTO.setAgentNo(checkAgentAuth(agentNo, fansActivityDTO.getAgentNo()));
        log.info("机构端会员管理-参与活动列表查询，请求地址：/api/fans/activityList，请求参数：{}", JSONObject.toJSONString(fansActivityDTO));
        IPage<FansActivityVO> page = fansService.getFansActivity(getIPage(), fansActivityDTO);
        log.info("机构端会员管理-参与活动列表查询，请求地址：/api/fans/activityList，返回结果：{}", JSONObject.toJSONString(page));
        return ApiRes.page(fansService.activityList(page));
    }

    /**
     * 认证商户列表
     */
    @PostMapping("/fansAuthAndMchList")
    public ApiRes fansAuthAndMchList(){
        FansDTO fansDTO = getObject(FansDTO.class);
        String agentNo = getCurrentUser().getAgentNo();
        fansDTO.setAgentNo(checkAgentAuth(agentNo, fansDTO.getAgentNo()));
        log.info("机构端认证商户列表，请求地址：/api/fans/fansAuthAndMchList，请求参数：{}", JSONObject.toJSONString(fansDTO));
        IPage<FansVO> list = fansService.fansAuthAndMchList(getIPage(),fansDTO);
        log.info("机构端认证商户列表，请求地址：/api/fans/fansAuthAndMchList，返回结果：{}", JSONObject.toJSONString(list));
        return ApiRes.page(list);
    }


    /**
     * 会员管理-福分记录
     *
     */
    @PostMapping("/recordOfBlessings")
    public ApiRes getRecordOfBlessings() {
        FansDTO  fansDTO = getObject(FansDTO.class);
        IPage<ScoreRecordTotalVO> page = fansService.getRecordOfBlessings(getIPage(), fansDTO);

        return ApiRes.page(page);
    }


}
